home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / emerald / emrldsys.lha / Kernel / Em / ecstub.4s < prev    next >
Encoding:
Text File  |  1990-08-17  |  8.4 KB  |  373 lines
  1.  
  2.  #       Definition of the run-time routines for emerald types.
  3.  #       Origin:  Norm Hutchinson, 1986-05-15.
  4.  #       
  5.  # /*  C O P Y R I G H T   N O T I C E :                                    */
  6.  # /* Copyright 1986 Eric Jul and Norm Hutchinson.  May not be used for any */
  7.  # /* purpose without written permission from the authors.            */
  8.  
  9.  #       This defines a number of simple code pieces called by compiled code.
  10.  
  11. LL0:
  12.  
  13. include(../h/vax.regdefs.h)
  14. include(../h/consts.h)
  15.  
  16. define(ementry,_$1: .globl   _$1)
  17. define(emexit,rsb)
  18.  
  19. define(dosaveregs,
  20.         moval       SS_regs`('regs_ssp`)'`,'scratch
  21.         movq        r3`,'(scratch)+
  22.         movq        r5`,'(scratch)+
  23.         movq        r7`,'(scratch)+
  24.         movl        r9`,'(scratch)+
  25.         movq        r11`,'(scratch)+
  26.         movq        r13`,'(scratch)
  27.         movl        _kernelsp`,'sp
  28.                                         )
  29.  
  30. define(c_restoreregs,
  31.         movl        _currentSSP`,'regs_ssp
  32.         moval       SS_regs `(' regs_ssp `)' `,' scratch
  33.         movq        (scratch)+`,'r3
  34.         movq        (scratch)+`,'r5
  35.         movq        (scratch)+`,'r7
  36.         movl        (scratch)+`,'r9
  37.         movq        (scratch)+`,'r11
  38.         movq        (scratch)`,'r13
  39.         rsb
  40.                                         )
  41.  
  42. # For calling C procedures
  43. define(call_c,
  44.         `dosaveregs'
  45.         `ifelse($1,3,
  46.         pushl       arg3
  47.         pushl       arg2
  48.         pushl       arg1)
  49.         ifelse($1,2,
  50.         pushl       arg2
  51.         pushl       arg1)
  52.         ifelse($1,1,
  53.         pushl       arg1)'
  54.         calls       `$'$1`,'_$2
  55.         `ifelse($3,1,
  56.         movl        r0`,'arg1)'
  57.     `c_restoreregs'
  58.         )
  59.  
  60.  
  61.  ########################################################################
  62.  #    string_getElement        is inlined
  63.  
  64.  ########################################################################
  65.  #    string_getSlice
  66.  #        entry:
  67.  #        arg1 == string pointer
  68.  #        arg2 == index of the first element
  69.  #        arg3 == length
  70.  #        exit:
  71.  #        arg1 == the result string pointer
  72.  
  73.         ementry(ems_getSlice)
  74.     tstl    r3
  75.     beql    8f
  76.     blss    9f
  77.     cmpl    r2,String_sizeInBytes (r1)
  78.     bgequ    9f
  79.     addl3    r2, r3, r0            # r0 is upperbound + 1
  80.     cmpl    r0,String_sizeInBytes (r1)
  81.     bgtru    9f
  82.     movq    r4,-(sp)
  83.     movab    String_data (r1)[r2], r2
  84.     movl    r3, r1
  85.     jsb    *$ _em_createString
  86.     pushl    r1
  87.     movc3    r3, (r2), String_data (r1)
  88.     movl    (sp)+, r1
  89.     movq    (sp)+, r4
  90.     emexit
  91. 8: #zero length
  92.     clrl    r1
  93.     jsb    *$ _em_createString
  94.     emexit
  95. 9: #range check
  96.     jmp    *$ _em_assertionFailure
  97.  
  98.  ########################################################################
  99.  #    string_compare            is inlined
  100.  #    This is here to make ementryset and ementryext the same.
  101.  
  102.     ementry(ems_compare)
  103.     halt
  104.     emexit
  105.  
  106.  ########################################################################
  107.  #    string_catenate
  108.  #        entry:
  109.  #        arg1 == left  string pointer
  110.  #        arg2 == right string pointer
  111.  #        exit:
  112.  #        arg1 == new string pointer
  113.  
  114.         ementry(ems_catenate)
  115.     pushl    r6
  116.     movq    r4, -(sp)
  117.     pushl    r2
  118.     pushl    r1
  119.     addl3    String_sizeInBytes (r1), String_sizeInBytes (r2), r1
  120.     jsb    *$ _em_createString
  121.     movl    r1, r6
  122.  
  123.     movl    (sp)+, r2
  124.     movc3    String_sizeInBytes (r2), String_data (r2), String_data (r1)
  125.  
  126.     movl    (sp)+, r2
  127.     movc3    String_sizeInBytes (r2), String_data (r2), (r3)
  128.  
  129.     movl    r6, r1
  130.     movq    (sp)+, r4
  131.     movl    (sp)+, r6
  132.     emexit
  133.  
  134.  #       Definition of the run-time routines for times.
  135.  
  136. define(sec,ROData_inlineData)
  137. define(usec,ROData_inlineData+4)
  138.  
  139.  ########################################################################
  140.  #
  141.  # Times are signed quantities.  They are represented by a signed integer
  142.  # number of seconds (s), and an unsigned integer number of microseconds
  143.  # (u), where 0 <= u < 1000000.  All these arithmetic operations maintain
  144.  # this invariant.
  145.  
  146.  ########################################################################
  147.  #    emtime_plus
  148.  #        entry:
  149.  #        arg1 == self
  150.  #        arg2 == the other time value
  151.  #        exit:
  152.  #        arg1 == the new result
  153.  
  154.         ementry(emtime_plus)
  155.     movq    arg1, -(sp)
  156.     movl    LOData_myCodePtr (arg1),arg1
  157.     jsb    *$ _em_localQuickCreate
  158.     movq    (sp)+, arg2
  159.     addl3    sec (arg3),sec (arg2),sec (arg1)
  160.     addl3    usec (arg3),usec (arg2),usec (arg1)
  161.     cmpl    usec (arg1),$1000000
  162.     blss    1f
  163.     subl2    $1000000,usec (arg1)
  164.     incl    sec (arg1)
  165. 1:
  166.     emexit
  167.  
  168.  ########################################################################
  169.  #    emtime_minus
  170.  #        entry:
  171.  #        arg1 == self time pointer
  172.  #        arg2 == the other time pointer
  173.  #        exit:
  174.  #        arg1 == the result time pointer
  175.  
  176.         ementry(emtime_minus)
  177.     movq    arg1, -(sp)
  178.     movl    LOData_myCodePtr (arg1),arg1
  179.     jsb    *$_em_localQuickCreate
  180.     movq    (sp)+, arg2
  181.     subl3    sec (arg3),sec (arg2),sec (arg1)
  182.     subl3    usec (arg3),usec (arg2),usec (arg1)
  183.     tstl    usec (arg1)
  184.     bgeq    1f
  185.     addl2    $1000000,usec (arg1)
  186.     decl    sec (arg1)
  187. 1:
  188.     emexit
  189.  
  190.  ########################################################################
  191.  #    emtime_times
  192.  #        entry:
  193.  #        arg1 == self time pointer
  194.  #        arg2 == the integer multiplicand
  195.  #        exit:
  196.  #        arg1 == the result time pointer
  197.  
  198.         ementry(emtime_times)
  199.     movl    arg2, -(sp)
  200.     movl    arg1, -(sp)
  201.     movl    LOData_myCodePtr (arg1),arg1
  202.     jsb    *$_em_localQuickCreate
  203.     movl    (sp)+, scratch            # scratch is the pointer to
  204.                         # the multiplicand. (sp) is
  205.                         # the multiplier
  206.     mull3    (sp), sec (scratch), sec (arg1)
  207.     emul    (sp)+, usec (scratch), $0, r2
  208.     ediv    $1000000, r2, r2, usec (arg1)
  209.     addl2    r2, sec (arg1)
  210. 1:
  211.     emexit
  212.  
  213.  ########################################################################
  214.  #    emtime_divide
  215.  #        entry:
  216.  #        arg1 == self time pointer
  217.  #        arg2 == the integer divisor
  218.  #        exit:
  219.  #        arg1 == the result time pointer
  220.  
  221.         ementry(emtime_divide)
  222.     movl    arg2, -(sp)
  223.     movl    arg1, -(sp)
  224.     movl    LOData_myCodePtr (arg1),arg1
  225.     jsb    *$_em_localQuickCreate
  226.     movl    (sp)+, scratch            # scratch is the pointer to
  227.                         # the dividend, (sp) is the
  228.                         # divisor
  229.     clrl    arg3
  230.     movl    sec (scratch), arg2
  231.     ediv    (sp), arg2, sec (arg1), arg2
  232.     emul    $1000000, arg2, usec (scratch), arg2
  233.     ediv    (sp)+, arg2, usec (arg1), arg2
  234.     bgeq    1f
  235.     addl2    $1000000,usec (arg1)
  236.     decl    sec (arg1)
  237. 1:    
  238.     emexit
  239.  
  240.  ########################################################################
  241.  #    emtime_compare
  242.  #        entry:
  243.  #        arg1 == left  time pointer
  244.  #        arg2 == right time pointer
  245.  #        exit:
  246.  #        condition codes set right
  247.  
  248.         ementry(emtime_compare)
  249.     cmpl    sec (arg1), sec (arg2)
  250.     bneq    1f
  251.     tstl    sec (arg1)
  252.     blss    2f
  253.     cmpl    usec (arg1), usec (arg2)
  254.     jbr    1f
  255. 2:    cmpl    usec (arg2), usec (arg1)
  256. 1:
  257.     emexit
  258.  
  259.  
  260.  #       Definition of the run-time routines for vectors.
  261.  
  262.  ########################################################################
  263.  #    vector_get[148]Slice
  264.  #        entry:
  265.  #        arg1 == vector pointer
  266.  #        arg2 == index of the first element
  267.  #        arg3 == length
  268.  #        exit:
  269.  #        arg1 == the result vector pointer
  270.  
  271.         ementry(emvector_get1Slice)
  272.     jmp    *$ _em_assertionFailure
  273.     emexit
  274.  
  275.         ementry(emvector_get4Slice)
  276.     jmp    *$ _em_assertionFailure
  277.     emexit
  278.  
  279.         ementry(emvector_get8Slice)
  280.     jmp    *$ _em_assertionFailure
  281.     emexit
  282.  
  283.  ########################################################################
  284.  #    vector_set[148]Slice
  285.  #        entry:
  286.  #        scratch == other vector pointer
  287.  #        arg1 == vector to change pointer
  288.  #        arg2 == index of the first element
  289.  #        arg3 == length
  290.  #        exit:
  291.  
  292.         ementry(emvector_set1Slice)
  293.     jmp    *$ _em_assertionFailure
  294.     emexit
  295.  
  296.         ementry(emvector_set4Slice)
  297.     jmp    *$ _em_assertionFailure
  298.     emexit
  299.  
  300.         ementry(emvector_set8Slice)
  301.     jmp    *$ _em_assertionFailure
  302.     emexit
  303.  
  304.  
  305.  ########################################################################
  306.  #    vector_catenate[148]
  307.  #        entry:
  308.  #        arg1 == left  vector pointer
  309.  #        arg2 == right vector pointer
  310.  #        exit:
  311.  #        arg1 == new vector pointer
  312.  
  313.         ementry(emvector_catenate1)
  314.     jmp    *$ _em_assertionFailure
  315.     emexit
  316.  
  317.         ementry(emvector_catenate4)
  318.     jmp    *$ _em_assertionFailure
  319.     emexit
  320.  
  321.     ementry(emvector_catenate8)
  322.     jmp    *$ _em_assertionFailure
  323.     emexit
  324.  
  325.     ementry(eminteger_asString)
  326.     .data
  327.     .align    2
  328. 1:    .ascii    "%d\0"
  329.     .text
  330.     movl    arg1, arg2
  331.     movab    1b, arg1
  332.     call_c(2,BuildString,1)
  333.     movl    r0,r1
  334.     emexit
  335.  
  336.     ementry(emboolean_asString)
  337.     .data
  338.     .align    2
  339. 1:    .ascii    "true\0"
  340.     .align    2
  341. 2:    .ascii    "false\0"
  342.     .text
  343.     tstl    arg1
  344.     jeql    3f
  345.     movab    1b, arg1
  346.     jbr    4f
  347. 3:    movab    2b, arg1
  348. 4:    clrl    arg2
  349.     call_c(2,BuildString,1)
  350.     emexit
  351.  
  352.     ementry(emcharacter_asString)
  353.     .data
  354.     .align    2
  355. 1:    .ascii    "%c\0"
  356.     .text
  357.     movl    arg1, arg2
  358.     movab    1b, arg1
  359.     call_c(2,BuildString,1)
  360.     emexit
  361.  
  362.     ementry(emreal_asString)
  363.     call_c(1,BuildRealString,1)
  364.     emexit
  365.  
  366.     ementry(emtime_asString)
  367.     call_c(1,BuildTimeString,1)
  368.     emexit
  369.  
  370.     ementry(emtime_asDate)
  371.     call_c(1,BuildTimeDate,1)
  372.     emexit
  373.